/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#ifndef __OPENCV_IMGPROC_TYPES_C_H__
#define __OPENCV_IMGPROC_TYPES_C_H__

#include "opencv2/core/core_c.h"
#include "opencv2/imgproc/types_c.h"

#ifdef __cplusplus
extern "C" {
#endif

	/* Connected component structure */
	typedef struct CvConnectedComp {
		double area;    /* area of the connected component  */
		CvScalar value; /* average color of the connected component */
		CvRect rect;    /* ROI of the component  */
		CvSeq* contour; /* optional component boundary
                      (the contour might have child contours corresponding to the holes)*/
	}
	CvConnectedComp;

	/* Image smooth methods */
	enum {
		CV_BLUR_NO_SCALE = 0,
		CV_BLUR  = 1,
		CV_GAUSSIAN  = 2,
		CV_MEDIAN = 3,
		CV_BILATERAL = 4
	};

	/* Filters used in pyramid decomposition */
	enum {
		CV_GAUSSIAN_5x5 = 7
	};

	/* Inpainting algorithms */
	enum {
		CV_INPAINT_NS      = 0,
		CV_INPAINT_TELEA   = 1
	};

	/* Special filters */
	enum {
		CV_SCHARR = -1,
		CV_MAX_SOBEL_KSIZE = 7
	};

	/* Constants for color conversion */
	enum {
		CV_BGR2BGRA    = 0,
		CV_RGB2RGBA    = CV_BGR2BGRA,

		CV_BGRA2BGR    = 1,
		CV_RGBA2RGB    = CV_BGRA2BGR,

		CV_BGR2RGBA    = 2,
		CV_RGB2BGRA    = CV_BGR2RGBA,

		CV_RGBA2BGR    = 3,
		CV_BGRA2RGB    = CV_RGBA2BGR,

		CV_BGR2RGB     = 4,
		CV_RGB2BGR     = CV_BGR2RGB,

		CV_BGRA2RGBA   = 5,
		CV_RGBA2BGRA   = CV_BGRA2RGBA,

		CV_BGR2GRAY    = 6,
		CV_RGB2GRAY    = 7,
		CV_GRAY2BGR    = 8,
		CV_GRAY2RGB    = CV_GRAY2BGR,
		CV_GRAY2BGRA   = 9,
		CV_GRAY2RGBA   = CV_GRAY2BGRA,
		CV_BGRA2GRAY   = 10,
		CV_RGBA2GRAY   = 11,

		CV_BGR2BGR565  = 12,
		CV_RGB2BGR565  = 13,
		CV_BGR5652BGR  = 14,
		CV_BGR5652RGB  = 15,
		CV_BGRA2BGR565 = 16,
		CV_RGBA2BGR565 = 17,
		CV_BGR5652BGRA = 18,
		CV_BGR5652RGBA = 19,

		CV_GRAY2BGR565 = 20,
		CV_BGR5652GRAY = 21,

		CV_BGR2BGR555  = 22,
		CV_RGB2BGR555  = 23,
		CV_BGR5552BGR  = 24,
		CV_BGR5552RGB  = 25,
		CV_BGRA2BGR555 = 26,
		CV_RGBA2BGR555 = 27,
		CV_BGR5552BGRA = 28,
		CV_BGR5552RGBA = 29,

		CV_GRAY2BGR555 = 30,
		CV_BGR5552GRAY = 31,

		CV_BGR2XYZ     = 32,
		CV_RGB2XYZ     = 33,
		CV_XYZ2BGR     = 34,
		CV_XYZ2RGB     = 35,

		CV_BGR2YCrCb   = 36,
		CV_RGB2YCrCb   = 37,
		CV_YCrCb2BGR   = 38,
		CV_YCrCb2RGB   = 39,

		CV_BGR2HSV     = 40,
		CV_RGB2HSV     = 41,

		CV_BGR2Lab     = 44,
		CV_RGB2Lab     = 45,

		CV_BayerBG2BGR = 46,
		CV_BayerGB2BGR = 47,
		CV_BayerRG2BGR = 48,
		CV_BayerGR2BGR = 49,

		CV_BayerBG2RGB = CV_BayerRG2BGR,
		CV_BayerGB2RGB = CV_BayerGR2BGR,
		CV_BayerRG2RGB = CV_BayerBG2BGR,
		CV_BayerGR2RGB = CV_BayerGB2BGR,

		CV_BGR2Luv     = 50,
		CV_RGB2Luv     = 51,
		CV_BGR2HLS     = 52,
		CV_RGB2HLS     = 53,

		CV_HSV2BGR     = 54,
		CV_HSV2RGB     = 55,

		CV_Lab2BGR     = 56,
		CV_Lab2RGB     = 57,
		CV_Luv2BGR     = 58,
		CV_Luv2RGB     = 59,
		CV_HLS2BGR     = 60,
		CV_HLS2RGB     = 61,

		CV_COLORCVT_MAX  = 100
	};


	/* Sub-pixel interpolation methods */
	enum {
		CV_INTER_NN        = 0,
		CV_INTER_LINEAR    = 1,
		CV_INTER_CUBIC     = 2,
		CV_INTER_AREA      = 3
	};

	/* ... and other image warping flags */
	enum {
		CV_WARP_FILL_OUTLIERS = 8,
		CV_WARP_INVERSE_MAP  = 16
	};

	/* Shapes of a structuring element for morphological operations */
	enum {
		CV_SHAPE_RECT      = 0,
		CV_SHAPE_CROSS     = 1,
		CV_SHAPE_ELLIPSE   = 2,
		CV_SHAPE_CUSTOM    = 100
	};

	/* Morphological operations */
	enum {
		CV_MOP_ERODE        = 0,
		CV_MOP_DILATE       = 1,
		CV_MOP_OPEN         = 2,
		CV_MOP_CLOSE        = 3,
		CV_MOP_GRADIENT     = 4,
		CV_MOP_TOPHAT       = 5,
		CV_MOP_BLACKHAT     = 6
	};

	/* Spatial and central moments */
	typedef struct CvMoments {
		double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */
		double  mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */
		double  inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */
	}
	CvMoments;

	/* Hu invariants */
	typedef struct CvHuMoments {
		double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */
	}
	CvHuMoments;

	/* Template matching methods */
	enum {
		CV_TM_SQDIFF        = 0,
		CV_TM_SQDIFF_NORMED = 1,
		CV_TM_CCORR         = 2,
		CV_TM_CCORR_NORMED  = 3,
		CV_TM_CCOEFF        = 4,
		CV_TM_CCOEFF_NORMED = 5
	};

	typedef float (CV_CDECL* CvDistanceFunction)( const float* a, const float* b, void* user_param );

	/* Contour retrieval modes */
	enum {
		CV_RETR_EXTERNAL = 0,
		CV_RETR_LIST = 1,
		CV_RETR_CCOMP = 2,
		CV_RETR_TREE = 3
	};

	/* Contour approximation methods */
	enum {
		CV_CHAIN_CODE = 0,
		CV_CHAIN_APPROX_NONE = 1,
		CV_CHAIN_APPROX_SIMPLE = 2,
		CV_CHAIN_APPROX_TC89_L1 = 3,
		CV_CHAIN_APPROX_TC89_KCOS = 4,
		CV_LINK_RUNS = 5
	};

	/*
	Internal structure that is used for sequental retrieving contours from the image.
	It supports both hierarchical and plane variants of Suzuki algorithm.
	*/
	typedef struct _CvContourScanner* CvContourScanner;

	/* Freeman chain reader state */
	typedef struct CvChainPtReader {
		CV_SEQ_READER_FIELDS()
		char      code;
		CvPoint   pt;
		schar     deltas[8][2];
	}
	CvChainPtReader;

	/* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
#define  CV_INIT_3X3_DELTAS( deltas, step, nch )            \
    ((deltas)[0] =  (nch),  (deltas)[1] = -(step) + (nch),  \
     (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch),  \
     (deltas)[4] = -(nch),  (deltas)[5] =  (step) - (nch),  \
     (deltas)[6] =  (step), (deltas)[7] =  (step) + (nch))


	/****************************************************************************************\
	*                              Planar subdivisions                                       *
	\****************************************************************************************/

	typedef size_t CvSubdiv2DEdge;

#define CV_QUADEDGE2D_FIELDS()     \
    int flags;                     \
    struct CvSubdiv2DPoint* pt[4]; \
    CvSubdiv2DEdge  next[4];

#define CV_SUBDIV2D_POINT_FIELDS()\
    int            flags;      \
    CvSubdiv2DEdge first;      \
    CvPoint2D32f   pt;         \
	int id;

#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)

	typedef struct CvQuadEdge2D {
		CV_QUADEDGE2D_FIELDS()
	}
	CvQuadEdge2D;

	typedef struct CvSubdiv2DPoint {
		CV_SUBDIV2D_POINT_FIELDS()
	}
	CvSubdiv2DPoint;

#define CV_SUBDIV2D_FIELDS()    \
    CV_GRAPH_FIELDS()           \
    int  quad_edges;            \
    int  is_geometry_valid;     \
    CvSubdiv2DEdge recent_edge; \
    CvPoint2D32f  topleft;      \
    CvPoint2D32f  bottomright;

	typedef struct CvSubdiv2D {
		CV_SUBDIV2D_FIELDS()
	}
	CvSubdiv2D;


	typedef enum CvSubdiv2DPointLocation {
		CV_PTLOC_ERROR = -2,
		CV_PTLOC_OUTSIDE_RECT = -1,
		CV_PTLOC_INSIDE = 0,
		CV_PTLOC_VERTEX = 1,
		CV_PTLOC_ON_EDGE = 2
	}
	CvSubdiv2DPointLocation;

	typedef enum CvNextEdgeType {
		CV_NEXT_AROUND_ORG   = 0x00,
		CV_NEXT_AROUND_DST   = 0x22,
		CV_PREV_AROUND_ORG   = 0x11,
		CV_PREV_AROUND_DST   = 0x33,
		CV_NEXT_AROUND_LEFT  = 0x13,
		CV_NEXT_AROUND_RIGHT = 0x31,
		CV_PREV_AROUND_LEFT  = 0x20,
		CV_PREV_AROUND_RIGHT = 0x02
	}
	CvNextEdgeType;

	/* get the next edge with the same origin point (counterwise) */
#define  CV_SUBDIV2D_NEXT_EDGE( edge )  (((CvQuadEdge2D*)((edge) & ~3))->next[(edge)&3])


	/* Contour approximation algorithms */
	enum {
		CV_POLY_APPROX_DP = 0
	};

	/* Shape matching methods */
	enum {
		CV_CONTOURS_MATCH_I1  = 1,
		CV_CONTOURS_MATCH_I2  = 2,
		CV_CONTOURS_MATCH_I3  = 3
	};

	/* Shape orientation */
	enum {
		CV_CLOCKWISE         = 1,
		CV_COUNTER_CLOCKWISE = 2
	};


	/* Convexity defect */
	typedef struct CvConvexityDefect {
		CvPoint* start; /* point of the contour where the defect begins */
		CvPoint* end; /* point of the contour where the defect ends */
		CvPoint* depth_point; /* the farthest from the convex hull point within the defect */
		float depth; /* distance between the farthest point and the convex hull */
	} CvConvexityDefect;


	/* Histogram comparison methods */
	enum {
		CV_COMP_CORREL        = 0,
		CV_COMP_CHISQR        = 1,
		CV_COMP_INTERSECT     = 2,
		CV_COMP_BHATTACHARYYA = 3
	};

	/* Mask size for distance transform */
	enum {
		CV_DIST_MASK_3   = 3,
		CV_DIST_MASK_5   = 5,
		CV_DIST_MASK_PRECISE = 0
	};

	/* Distance types for Distance Transform and M-estimators */
	enum {
		CV_DIST_USER    = -1, /* User defined distance */
		CV_DIST_L1      = 1,  /* distance = |x1-x2| + |y1-y2| */
		CV_DIST_L2      = 2,  /* the simple euclidean distance */
		CV_DIST_C       = 3,  /* distance = max(|x1-x2|,|y1-y2|) */
		CV_DIST_L12     = 4,  /* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */
		CV_DIST_FAIR    = 5,  /* distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */
		CV_DIST_WELSCH  = 6,  /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */
		CV_DIST_HUBER   = 7   /* distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */
	};


	/* Threshold types */
	enum {
		CV_THRESH_BINARY      = 0, /* value = value > threshold ? max_value : 0       */
		CV_THRESH_BINARY_INV  = 1, /* value = value > threshold ? 0 : max_value       */
		CV_THRESH_TRUNC       = 2, /* value = value > threshold ? threshold : value   */
		CV_THRESH_TOZERO      = 3, /* value = value > threshold ? value : 0           */
		CV_THRESH_TOZERO_INV  = 4, /* value = value > threshold ? 0 : value           */
		CV_THRESH_MASK        = 7,
		CV_THRESH_OTSU        = 8  /* use Otsu algorithm to choose the optimal threshold value;
                                 combine the flag with one of the above CV_THRESH_* values */
	};

	/* Adaptive threshold methods */
	enum {
		CV_ADAPTIVE_THRESH_MEAN_C  = 0,
		CV_ADAPTIVE_THRESH_GAUSSIAN_C  = 1
	};

	/* FloodFill flags */
	enum {
		CV_FLOODFILL_FIXED_RANGE = (1 << 16),
		CV_FLOODFILL_MASK_ONLY   = (1 << 17)
	};


	/* Canny edge detector flags */
	enum {
		CV_CANNY_L2_GRADIENT  = (1 << 31)
	};

	/* Variants of a Hough transform */
	enum {
		CV_HOUGH_STANDARD = 0,
		CV_HOUGH_PROBABILISTIC = 1,
		CV_HOUGH_MULTI_SCALE = 2,
		CV_HOUGH_GRADIENT = 3
	};


	/* Fast search data structures  */
	struct CvFeatureTree;
	struct CvLSH;
	struct CvLSHOperations;

#ifdef __cplusplus
}
#endif

#endif
